﻿#define _CRT_SECURE_NO_WARNINGS 1
//2.从右向左滚动显示弹幕
//#include <stdio.h>
//#include <time.h>
//#include <string.h>
//int sleep(unsigned long x)
//{
//	clock_t c1 = clock();//类型为算数类型
//	clock_t c2;
//	do
//	{
//		if ((c2 = clock()) == (clock_t)-1)//判断是否获取成功
//		{
//			return 0;
//		}
//	} while (1000.0*(c2 - c1) / CLOCKS_PER_SEC < x);//判断转换为秒
//	return 1;
//}
//int main()
//{
//	int i = 0;
//	int cnt = 0;//第几个字符在最前面显示
//	char name[] = "  hello world  ";//为了美观适量的加入了空格。
//	int len = strlen(name);//计算数组长度
//	while (1)
//	{
//		putchar('\r');//转义字符'\r'将光标移动到本行开头
//		for (int i = 0; i < len; i++)
//		{
//			if (cnt + i < len)//这个if与else语句自己调试跟着看一遍就能明白
//			{
//				putchar(name[cnt + i]);
//			}
//			else
//			{
//				putchar(name[cnt + i - len]);
//			}
//		}
//		fflush(stdout);//输出缓冲区
//		sleep(500);//停顿
//		if (cnt < len - 1)
//		{
//			cnt++;
//		}
//		else
//		{
//			cnt = 0;
//		}
//	}
//	return 0;
//}









//1.弹幕显示
//#include <stdio.h>
//#include <time.h>
//#include <string.h>
//int sleep(unsigned long x)
//{
//	clock_t c1 = clock();//类型为算数类型
//	clock_t c2;//算数类型
//	do
//	{
//		if ((c2 = clock()) == (clock_t)-1)//判断是否获取成功
//		{
//			return 0;
//		}
//	} while (1000.0*(c2 - c1) / CLOCKS_PER_SEC < x);//判断转换为秒
//    return 1;
//}
//int main()
//{
//	char name[] = "hello world";//需要打印的字符串
//	int len = strlen(name);//计算字符串长度
//	while (1)//注意循环判断始终为真，所以结束程序我们需要手动关闭
//	{
//		for (int i = 0; i < len; i++)//循环打印每个字符
//		{
//			putchar(name[i]);//putchar打印字符。
//			fflush(stdout);//输出缓冲区。
//			sleep(500);//每个字节打印停顿
//		}
//		for (int i = 0; i < len; i++)
//		{
//			printf("\b \b");//转义字符'\b'为退格符
//			fflush(stdout);//输出缓冲区
//			sleep(500);//每次删除字节后停顿。
//		}
//
//	}
//	return 0;
//}









//假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
//
//给你一个整数数组  flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/can-place-flowers
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool canPlaceFlowers(int* flowerbed, int flowerbedSize, int n){
//	int num = 1;
//	int i = 0;
//	for (i = 0; i<flowerbedSize; i++)
//	{
//		if (flowerbed[i] == 0)
//		{
//			num++;
//			if (i == flowerbedSize - 1)
//			{
//				num++;
//			}
//			if (num>2)
//			{
//				n--;
//				num = 1;
//			}
//		}
//		else
//		{
//			num = 0;
//		}
//	}
//	if (n <= 0)
//	{
//		return true;
//	}
//	return false;
//}







//给定一个字符串 s，计算具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是连续的。
//
//重复出现的子串要计算它们出现的次数。
//int countBinarySubstrings(char * s){
//	int count = 1;
//	int i = 0;
//	int len = strlen(s);
//	int num = 0;
//	int n = 0;
//	for (i = 0; i<len - 1; i++)
//	{
//		if (s[i] == s[i + 1])
//		{
//			count++;
//		}
//		else
//		{
//			num = count;
//			count = 1;
//		}
//		if (num >= count)
//		{
//			n++;
//		}
//	}
//	return n;
//}







//给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。
//bool hasAlternatingBits(int n){
//	while (n>1)
//	{
//		int x = n & 1;
//		n >>= 1;
//		if (x == (n & 1))
//		{
//			return false;
//		}
//	}
//	return true;
//}







//给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 - 1。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/binary-search
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int search(int* nums, int numsSize, int target){
//	int r = numsSize - 1;
//	int l = 0;
//	int m = 0;
//	while (l <= r)
//	{
//		m = (r + l) / 2;
//		if (nums[m]>target)
//		{
//			r = m - 1;
//		}
//		else if (nums[m]<target)
//		{
//			l = m + 1;
//		}
//		else if (nums[m] == target)
//		{
//			return m;
//		}
//	}
//	return -1;
//}









//给你一个整数数组 nums ，请计算数组的 中心下标 。
//
//数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
//
//如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
//
//如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 - 1 。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/find-pivot-index
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int pivotIndex(int* nums, int numsSize){
//	int countr = 0;
//	int countl = 0;
//	for (int i = 0; i<numsSize; i++)
//	{
//		countr = 0;
//		for (int k = 0; k<i; k++)
//		{
//			countr += nums[k];
//		}
//		if (i == numsSize - 1)
//		{
//			if (countr == 0)
//			{
//				return i;
//			}
//			else
//			{
//				return -1;
//			}
//		}
//		countl = 0;
//		for (int j = i + 1; j<numsSize; j++)
//		{
//			countl += nums[j];
//		}
//		if (countr == countl)
//		{
//			return i;
//		}
//	}
//	return -1;
//}







//有两种特殊字符。第一种字符可以用一比特0来表示。第二种字符可以用两比特(10 或 11)来表示。
//
//现给一个由若干比特组成的字符串。问最后一个字符是否必定为一个一比特字符。给定的字符串总是由0结束。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/1-bit-and-2-bit-characters
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool isOneBitCharacter(int* bits, int bitsSize){
//	int i = 0;
//	while (i<bitsSize - 1)
//	{
//		if (bits[i] == 1)
//		{
//			i += 2;
//		}
//		else
//		{
//			i++;
//		}
//	}
//	if (i<bitsSize)
//	{
//		return true;
//	}
//	return false;
//}







//给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。
//
//请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 - 1 。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/largest-number-at-least-twice-of-others
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int dominantIndex(int* nums, int numsSize){
//	int max = 0;
//	int min = 0;
//	int j = 0;
//	for (int i = 0; i<numsSize; i++)
//	{
//		if (nums[i]>max)
//		{
//			min = max;
//			max = nums[i];
//			j = i;
//		}
//		else if (nums[i]>min)
//		{
//			min = nums[i];
//		}
//	}
//	if (min * 2>max)
//	{
//		return -1;
//	}
//	return j;
//}









//数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
//
//每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。
//
//请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。
//int minCostClimbingStairs(int* cost, int costSize){
//	int dp[costSize + 1];
//	dp[0] = 0;
//	dp[1] = 0;
//	for (int i = 2; i <= costSize; i++)
//	{
//		dp[i] = fmin(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
//	}
//	return dp[costSize];
//}








//给你一个排序后的字符列表 letters ，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。
//
//在比较时，字母是依序循环出现的。举个例子：
//
//如果目标字母 target = 'z' 并且字符列表为 letters = ['a', 'b']，则答案返回 'a'
//char nextGreatestLetter(char* letters, int lettersSize, char target){
//	int i = 0;
//	if (target >= letters[lettersSize - 1])
//	{
//		return letters[0];
//	}
//	while (letters[i] <= target)
//	{
//		i++;
//	}
//	return letters[i];
//}







//在大小为 2N 的数组 A 中有 N + 1 个不同的元素，其中有一个元素重复了 N 次。
//
//返回重复了 N 次的那个元素。
//int cmp(void* a, void* b)
//{
//	return *(int *)a - *(int *)b;
//}
//int repeatedNTimes(int* nums, int numsSize){
//	qsort(nums, numsSize, sizeof(int), cmp);
//	for (int i = 1; i<numsSize; i++)
//	{
//		if (nums[i] == nums[i - 1])
//		{
//			return nums[i];
//		}
//	}
//	return -1;
//}